package com.liangtian.mdm.material.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.liangtian.mdm.material.dao.WlLbmbtzlDao;
import com.liangtian.mdm.material.dao.WlLbmbtzlqzDao;
import com.liangtian.mdm.material.model.WlLbmbTzlfh;
import com.liangtian.mdm.material.model.WlLbmbtzl;
import com.liangtian.mdm.material.model.WlLbmbtzlDto;
import com.liangtian.mdm.material.model.WlLbmbtzlqz;
import com.liangtian.mdm.material.service.WlLbmbtzlService;
import com.liangtian.mdm.system.parameter.service.SysParameterService;
import com.liangtian.mdm.system.parameter.utils.SysParamUtil;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class WlLbmbtzlServiceImpl implements WlLbmbtzlService {

    @Autowired
    private WlLbmbtzlDao wlLbmbtzlDao;

    @Autowired
    private WlLbmbtzlqzDao wlLbmbtzlqzDao;

    @Autowired
    private SysParameterService sysParameterService;

    // Session中保存的当前登录用户的信息
    //@Value("${ConstantBean.CURRENT_SESSION_USER}")
    //private String ConstantBean.CURRENT_SESSION_USER;

    @Override
    public int getWlLbmbtzlListCountByCond(WlLbmbtzl tzl) {
        Map<String, Object> map = new HashMap<>();
        map.put("wl_lbmb_id", tzl.getWl_lbmb_id());
        map.put("status", tzl.getStatus());
        return wlLbmbtzlDao.getWlLbmbtzlListCountByCond(map);
    }

    @Override
    public List<WlLbmbtzlDto> getWlLbmbtzlDtoList(String wlLbmbId) {
        List<WlLbmbtzlDto> list = getWlLbmbtzlDto(wlLbmbId);
        if (list != null) {
            for (int i = 0; i < list.size(); i++) {
                WlLbmbtzlDto tzl = list.get(i);
                WlLbmbtzlqz qzcond = new WlLbmbtzlqz();
                qzcond.setWl_lbmbtzl_id(tzl.getId());
                qzcond.setStatus("1");
                qzcond.setPageNum(1);
                qzcond.setLength(200000);
                //qzcond.setOpe("4");
                tzl.setTzlzList(wlLbmbtzlqzDao.getWlLbmbtzlqzListByCond(qzcond));
            }
        }
        return list;
    }

    private List<WlLbmbtzlDto> getWlLbmbtzlDto(String wlLbmbId) {
        List<WlLbmbtzlDto> list = wlLbmbtzlDao.getWlLbmbtzlDtoList(wlLbmbId);
        if (list != null) {
            //--edit by wangyk at 180409 start:提升性能需要，不使用下面for循环，且每个for循环再执行两个sql查询的逻辑，改成只需要一个sql查询的逻辑
            List<WlLbmbTzlfh> fhAndJldwList = wlLbmbtzlDao.getWlLbmbTzlfhAndJldwByCond(wlLbmbId);

            for (int i = 0; i < list.size(); i++) {
                WlLbmbtzlDto tzl = list.get(i);

                List<WlLbmbTzlfh> qzfhList = new ArrayList<WlLbmbTzlfh>();
                List<WlLbmbTzlfh> hzfhList = new ArrayList<WlLbmbTzlfh>();
                List<WlLbmbTzlfh> ljfhList = new ArrayList<WlLbmbTzlfh>();
                List<WlLbmbTzlfh> jldwList = new ArrayList<WlLbmbTzlfh>();
                tzl.setQzfhList(qzfhList);
                tzl.setHzfhList(hzfhList);
                tzl.setLjfhList(ljfhList);
                tzl.setJldwList(jldwList);

                String tzlIdi = tzl.getId();
                for (int j = 0; j < fhAndJldwList.size(); j++) {
                    WlLbmbTzlfh tzlfh = fhAndJldwList.get(j);
                    Integer tzlIdj = tzlfh.getWl_lbmbtzl_id();
                    if (tzlIdi.equals(tzlIdj)) {
                        if ("1".equals(tzlfh.getFh_type())) {
                            if (qzfhList.size() == 0 && (StringUtils.isEmpty(tzl.getQzfhsfkk()) || tzl.getQzfhsfkk().equals("0"))) {
                                WlLbmbTzlfh kfh = new WlLbmbTzlfh();
                                kfh.setId(1);
                                kfh.setFhname("");
                                qzfhList.add(kfh);
                            }
                            qzfhList.add(tzlfh);
                        }
                        if ("2".equals(tzlfh.getFh_type())) {
                            if (hzfhList.size() == 0 && (StringUtils.isEmpty(tzl.getHzfhsfkk()) || tzl.getHzfhsfkk().equals("0"))) {
                                WlLbmbTzlfh kfh = new WlLbmbTzlfh();
                                kfh.setId(2);
                                kfh.setFhname("");
                                hzfhList.add(kfh);
                            }
                            hzfhList.add(tzlfh);
                        }
                        if ("3".equals(tzlfh.getFh_type())) {
                            ljfhList.add(tzlfh);
                        }
                        if ("4".equals(tzlfh.getFh_type())) {
                            jldwList.add(tzlfh);
                        }
                    }
                }
            }
            //--edit by wangyk at 180409 end

			/*
			for(int i=0;i<list.size();i++){
				WlLbmbtzlDto tzl = list.get(i);
				Map cxMap = new HashMap();
				cxMap.put("wl_mbtzl_wym", tzl.getId());
				List<WlLbmbTzlfh> fhList = wlLbmbtzlDao.getWlLbmbTzlfhByCond(cxMap);
				List<WlLbmbTzlfh> jldwList = wlLbmbtzlDao.getWlLbmbTzlJldwByCond(cxMap);
				tzl.setJldwList(jldwList);
				if(fhList!=null && fhList.size()>0){
					List qzfh = new ArrayList();
					List hzfh = new ArrayList();
					List ljfh = new ArrayList();
					for(WlLbmbTzlfh fh : fhList){
						if(fh.getFh_type().equals("1")){
							if(qzfh.size()==0 && (StringUtils.isEmpty(tzl.getQzfhsfkk())||tzl.getQzfhsfkk().equals("0"))){
								WlLbmbTzlfh kfh = new WlLbmbTzlfh();
								kfh.setId("");
								kfh.setFhname("");
								qzfh.add(kfh);
							}
							qzfh.add(fh);
						}
						if(fh.getFh_type().equals("2")){
							if(hzfh.size()==0 && (StringUtils.isEmpty(tzl.getHzfhsfkk())||tzl.getHzfhsfkk().equals("0"))){
								WlLbmbTzlfh kfh = new WlLbmbTzlfh();
								kfh.setId("");
								kfh.setFhname("");
								hzfh.add(kfh);
							}
							hzfh.add(fh);
						}
						if(fh.getFh_type().equals("3")){
							ljfh.add(fh);
						}
					}
					tzl.setQzfhList(qzfh);
					tzl.setHzfhList(hzfh);
					tzl.setLjfhList(ljfh);
				}
			}
			*/
        }
        return list;
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public PageInfo getWlLbmbtzlListByCond(Map<String, Object> map) {
        PageInfo<List<WlLbmbtzl>> pageInfo = null;
        try {
            Object pNo = map.get("pageNum");
            int pageNum, pageSize;
            // export
            if (pNo != null && !"NaN".equals(pNo)) {
                pageNum = Integer.parseInt(pNo.toString());// 页码
            } else {
                pageNum = 1;
            }
            // pageSize=0时不分页
            pageSize = Integer.parseInt(map.get("limit").toString());// 模型定义页面要显示数据条数
            // 例如
            // 10,20,50,100
            PageHelper.startPage(pageNum, pageSize);// 开始分页标志（当前页，显示条数）

            List<WlLbmbtzl> list = wlLbmbtzlDao.getWlLbmbtzlListByCond(map);
            pageInfo = new PageInfo(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return pageInfo;
    }

    @Override
    public Map<String, Object> getWlLbmbtzlById(WlLbmbtzl tzl) {
        return wlLbmbtzlDao.getWlLbmbtzlById(tzl);
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public PageInfo getWlLbmbTzlfhByCond(Map<String, Object> map) {
        PageInfo<List<WlLbmbTzlfh>> pageInfo = null;
        try {
            Object pNo = map.get("pageNum");
            int pageNum, pageSize;
            // export
            if (pNo != null && !"NaN".equals(pNo)) {
                pageNum = Integer.parseInt(pNo.toString());// 页码
            } else {
                pageNum = 1;
            }
            // pageSize=0时不分页
            pageSize = Integer.parseInt(map.get("limit").toString());// 模型定义页面要显示数据条数
            // 例如
            // 10,20,50,100
            PageHelper.startPage(pageNum, pageSize);// 开始分页标志（当前页，显示条数）
            List<WlLbmbTzlfh> list = wlLbmbtzlDao.getWlLbmbTzlfhByCond(map);
            pageInfo = new PageInfo(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return pageInfo;
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    @Override
    public PageInfo getWlLbmbTzlJldwByCond(Map<String, Object> map) {
        PageInfo<List<WlLbmbTzlfh>> pageInfo = null;
        try {
            Object pNo = map.get("pageNum");
            int pageNum, pageSize;
            // export
            if (pNo != null && !"NaN".equals(pNo)) {
                pageNum = Integer.parseInt(pNo.toString());// 页码
            } else {
                pageNum = 1;
            }
            // pageSize=0时不分页
            pageSize = Integer.parseInt(map.get("limit").toString());// 模型定义页面要显示数据条数
            // 例如
            // 10,20,50,100
            PageHelper.startPage(pageNum, pageSize);// 开始分页标志（当前页，显示条数）
            List<WlLbmbTzlfh> list = wlLbmbtzlDao.getWlLbmbTzlJldwByCond(map);
            pageInfo = new PageInfo(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return pageInfo;
    }

    @Override
    public int getTzlFhAddCount(WlLbmbTzlfh tzlfh) {
        Map<String, Object> map = new HashMap<>();
        map.put("wl_lbmbtzl_id", tzlfh.getWl_lbmbtzl_id());
        map.put("fh_type", tzlfh.getFh_type());
        map.put("fh_wym", tzlfh.getFh_wym());
        return wlLbmbtzlDao.getTzlFhAddCount(map);
    }

    @Override
    public int insertWlLbmbTzlfh(WlLbmbTzlfh tzlfh) {
        return wlLbmbtzlDao.insertWlLbmbTzlfh(tzlfh);
    }

    @Override
    public int deleteWlLbmbTzlfh(Map<String, Object> map) {
        return wlLbmbtzlDao.deleteWlLbmbTzlfh(map);
    }

    @Override
    public int getAddMbTzlCountByTzlmc(WlLbmbtzl tzl) {
        Map<String, Object> map = new HashMap<>();
        map.put("tzlmc", tzl.getTzlmc());
        map.put("wl_lbmb_id", tzl.getWl_lbmb_id());
        return wlLbmbtzlDao.getAddMbTzlCountByTzlmc(map);
    }

    @Override
    public int insertWlLbmbtzl(WlLbmbtzl tzl) {
        return wlLbmbtzlDao.insertWlLbmbtzl(tzl);
    }

    @Override
    public WlLbmbtzl getMbTzlById(WlLbmbtzl tzl) {
        return wlLbmbtzlDao.getMbTzlById(tzl);
    }

    @Override
    public int checkEditMbTzlCount(Map<String, Object> cond) {
        return wlLbmbtzlDao.checkEditMbTzlCount(cond);
    }

    @Override
    public void updateWlLbmbtzl(WlLbmbtzl tzl) {
        wlLbmbtzlDao.updateWlLbmbtzl(tzl);

    }

    @Override
    public int updateWlLbmbtzlByMap(Map<String, Object> map) {
        return wlLbmbtzlDao.updateWlLbmbtzlByMap(map);
    }

    @Override
    public int deleteWlLbmbTzlfhByTzlid(Map<String, Object> map) {
        return wlLbmbtzlDao.deleteWlLbmbTzlfhByTzlid(map);
    }

    @Override
    public List<WlLbmbtzlDto> getWlLbmbtzlDtoListForApplyPage(String wlLbmbId, boolean flag) {

        List<WlLbmbtzlDto> list = getWlLbmbtzlDto(wlLbmbId);
        if (list != null) {
//			//特征量取值控件加载取值个数限制
//			//int limit = Integer.parseInt(SysParametersUtil.getParameterValueForDefault("tzlzComboboxLimit","200"));
//			//2017-09-26 update by liyang 去掉加载取值个数限制 如果有限制并且大于限制个数 特征量列表相应的取值或取不到
//
//			//--edit by wangyk at 180308:系统参数不实时查询数据库，节约性能
//			//int limit = Integer.parseInt(sysParameterService.getSysParamValue("tzlzComboboxLimit","200"));
//			int limit = Integer.parseInt(SysParamUtil.getParameterValue("tzlzComboboxLimit","200"));
//			//System.out.println("-->"+limit);
//			Map<String, Object> cond = new HashMap<>();
//			cond.put("wl_lbmb_id", wlLbmbId);
//			for(int i=0;i<list.size();i++){
//				WlLbmbtzlDto tzl = list.get(i);
//				cond.put("id", tzl.getId());
//				List<String> glTzl = this.getWlLbmbTzlGl(cond);//找出其相关联的所有特征量
//				if(!StringUtils.isEmpty(glTzl)){
//					tzl.setMain_std_tzl_id(StringUtil.arrayToStringBySplit(glTzl, ","));
//				}
//				/*else{//如果不存在相关联的特征量
//					WlLbmbtzlqz qzcond = new WlLbmbtzlqz();
//					qzcond.setWl_lbmbtzl_id(tzl.getId());
//					qzcond.setStatus("1");
//					int count = wlLbmbtzlqzDao.getWlLbmbtzlqzListCountByCond(qzcond);
//					tzl.setTzlzCount(count);
//					if(count>0 && count<=limit){//特征量取值个数超过限制的将不取出
//						//qzcond.setPageNo(1);
//						//qzcond.setPageSize(limit);
//						tzl.setTzlzList(wlLbmbtzlqzDao.getWlLbmbtzlqzListByCond(qzcond));
//					}
//				}*/
//				//update--jyh
//				//原关联特征量取值 在页面中通过select的onShowPanel事件来处理，在bootstrap中我没有找到(如果哪位好汉知道类似的可以改回原逻辑)在此将原逻辑稍作调整
//				WlLbmbtzlqz qzcond = new WlLbmbtzlqz();
//				qzcond.setWl_lbmbtzl_id(tzl.getId());
//				qzcond.setStatus("1");
//				int count = wlLbmbtzlqzDao.getWlLbmbtzlqzListCountByCond(qzcond);
//				tzl.setTzlzCount(count);
//				if(count>0){
//					if(flag)
//						tzl.setTzlzList(wlLbmbtzlqzDao.getWlLbmbtzlqzListByCond(qzcond));
//					else{
//						if(count<=limit){//特征量取值个数超过限制的将不取出
//							//qzcond.setPageNo(1);
//							//qzcond.setPageSize(limit);
//							tzl.setTzlzList(wlLbmbtzlqzDao.getWlLbmbtzlqzListByCond(qzcond));
//						}
//					}
//				}
//			}

            //--edit by wangyk at 180409 start :优化性能，减少不必要的数据库查询，注释掉上面原来使用的全部逻辑，改成使用新的方式。
            int limit = Integer.parseInt(SysParamUtil.getParameterValue("tzlzComboboxLimit", "200"));
            Map<String, Object> cond = new HashMap<>();
            cond.put("wl_lbmb_id", wlLbmbId);
            List<String> countResultList = wlLbmbtzlqzDao.getWlLbmbtzlqzListCountByMbId(wlLbmbId);

            Map<String, Integer> countResultMap = new HashMap<String, Integer>();
            List<String> tzlIdList = new ArrayList<String>();
            for (String str : countResultList) {
                String tzlId = str.split(",,")[0];
                int count = Integer.parseInt(str.split(",,")[1]);
                countResultMap.put(tzlId, count);
                //--控制哪些tzlId继续查询取值明细列表，从excel导入逻辑进来的都要再查，否则需满足count<=limit的条件
                if (count > 0) {
                    if (flag)
                        tzlIdList.add(tzlId);
                    else {
                        if (count <= limit)
                            tzlIdList.add(tzlId);
                    }
                }
            }

            Map<String, List<WlLbmbtzlqz>> tzlqzAllMap = new HashMap<String, List<WlLbmbtzlqz>>();
            if (!CollectionUtils.isEmpty(tzlIdList)) {
                //--仅查询位于tzlIdList中的取值，sql内部已经按照tzlId/xh排好序
                List<WlLbmbtzlqz> tzlqzAllList = wlLbmbtzlqzDao.getWlLbmbtzlqzListByTzlIdList(tzlIdList);
                //--转map，key为tzlId
                for (WlLbmbtzlqz temp : tzlqzAllList) {
                    String tzlId = temp.getWl_lbmbtzl_id();
                    if (tzlqzAllMap.containsKey(tzlId))
                        tzlqzAllMap.get(tzlId).add(temp);
                    else {
                        List<WlLbmbtzlqz> tempList = new ArrayList<WlLbmbtzlqz>();
                        tempList.add(temp);
                        tzlqzAllMap.put(tzlId, tempList);
                    }
                }
            }

            for (int i = 0; i < list.size(); i++) {
                WlLbmbtzlDto tzl = list.get(i);
                int count = countResultMap.get(tzl.getId());
                tzl.setTzlzCount(count);
                List<WlLbmbtzlqz> tzlzList = tzlqzAllMap.get(tzl.getId());
                tzl.setTzlzList(tzlzList);
            }
            //--edit by wangyk at 180409 end
        }
        return list;
    }

    @Override
    public List<String> getWlLbmbTzlGl(Map<String, Object> map) {
        return wlLbmbtzlDao.getWlLbmbTzlGl(map);
    }

    @Override
    public List<WlLbmbtzl> getWlLbmbtzlLanListSimple(Map<String, Object> cond) {
        return wlLbmbtzlDao.getWlLbmbtzlLanListSimple(cond);
    }

    @Override
    public WlLbmbtzl getWlLbmbtzlById(String id) {
        return wlLbmbtzlDao.getWlLbmbtzlById2(id);
    }

    @Override
    public List<WlLbmbtzl> getWlLbmbtzlByCond(Map<String, Object> cond) {
        return wlLbmbtzlDao.getWlLbmbtzlListByCond(cond);
    }

    @Override
    public List<WlLbmbtzl> getWlLbmbtzlListSimple(String wl_lbmb_id) {
        return wlLbmbtzlDao.getWlLbmbtzlListSimple(wl_lbmb_id);
    }

    /**
     * <p>TODO 删除物料模板特征量的方法
     * 恒力这块出现这个需要物理删除特整理的方法，所以，添加此处
     * 否则特征量表和特征量取值表的脏数据会太多
     * </p>
     *
     * @param : @param map
     * @param : @return
     * @author : xiaoliu
     * @date :2017年12月22日下午5:01:57
     */

    @Override
    public int deleteWlLbmbTzlByMap(Map<String, Object> map) {

        return wlLbmbtzlDao.deleteWlLbmbTzlByMap(map);

    }

    @Override
    public int getTzlMaxXh(WlLbmbtzl tzl) {
        Map<String, Object> map = new HashMap<>();
        map.put("wl_lbmb_id", tzl.getWl_lbmb_id());
        return wlLbmbtzlDao.getTzlMaxXh(map);
    }

}
